Getting Started

To start a proper shell and initialize your path, run the following commands. (martin is on purpose. Don't change the username to your own account).

$ bash
$ source /home/martin/strategoxt/env.sh

Don't forget to run these commands again if you open a new shell.

Download the file ipa06-templates.tar.gz to your home directory, create a working directory for yourself, and unpack the file:

$ mkdir <working-dir>
$ cd <working-dir>
$ tar zxvf ~/ipa06-templates.tar.gz

The tarball contains a very small Stratego program to test the Stratego/XT installation. If the following commands do not succeed, then please scream for help.

$ cd welcome
$ strc -i welcome.str -la stratego-lib
$ ./welcome
Great, Stratego/XT works!
$ cd ..

For experimenting with the Stratego language the Stratego Shell can be useful. A small session that you can try to see if it works.:

$ stratego-shell
stratego> import libstratego-lib
stratego> ![1, 2, 3]
[1,2,3]
stratego> fetch(?x)
[1,2,3]
stratego> :binding x
x is bound to 1
stratego> :quit
$ 

Java Tools

(work in directory tools)

In these exercises we will use the Java support packages of Stratego/XT. The tool parse-java is used to parse Java programs to an abstract syntax tree represented as an ATerm.

$ echo "class Foo {}" | parse-java | pp-aterm
CompilationUnit(
  None()
, []
, [ ClassDec(
      ClassDecHead([], Id("Foo"), None(), None(), None())
    , ClassBody([])
    )
  ]
)

For parsing simple expressions, you don't have to create an entire class:

$ echo "1+2" | parse-java -s Expr | pp-aterm
Plus(Lit(Deci("1")), Lit(Deci("2"))

You can also put the class in a file, which is useful if you are going to try bigger examples. For files, use parse-java -i Foo.java.

Java-front also features a pretty-printer for Java. You can apply this pretty-printer in a pipeline with the parser:

$ parse-java -i HelloWorld.java | pp-java

Compile a simple Java source file to a .class file and decompile it using the tool class2aterm:

$ javac HelloWorld.java
$ class2aterm -i HelloWorld.class | pp-aterm

Take a brief look at the structure of this aterm. This invocation does not disassemble the code. For this, you have to pass -c as an argument to class2aterm:

$ class2aterm -i HelloWorld.class -c | pp-aterm

As you can see, the output is quite big. If you want to scroll through the output, then you can add less to the pipeline. You can exit less and return to the command-line using q.

$ class2aterm -i HelloWorld.class -c | pp-aterm | less

Rewriting strategies

Introduce Braces for Control-flow Statements

(work in directory introduce-braces)

Implement a set of conditional rewrite rules that introduces blocks in the branches of control-flow statements, but only if the blocks are missing. Cover a few different control-flow statements. Use the template introduce-braces.str.

Compile and apply:

$ cd introduce-braces
$ ./compile.sh
$ parse-java -i Sample1.java | ./introduce-braces | pp-java
public class Sample1
{
  int foo()
  {
    if(true)
    {
      return 1;
    }
    else
    {
      return 2;
    }
  }
}

$ parse-java -i Sample2.java | ./introduce-braces | pp-java
public class Sample2
{
  void foo()
  {
    while(true)
    {
      doWhatever();
    }
    oops();
  }
}

Warn for Return Statements in Finally Clause

(work in directory return-finally)

Note: If the previous exercises took you more than an hour, then you might want to skip to the next exercises on type-unifying strategies.

A return statement in a finally clause should be avoided, because this return statement can completely change the original result of the method: a returned value or a thrown exception in the try part. This is not the purpose of a finally clause, therefore compilers often warn about this:

class ReturnFinally
{
  boolean error;

  int g()
  {
    if(error)
      throw new IllegalStateException();
    else
      return 4;
  }

  int f()
  {
    try
    {
      return g();
    }
    finally
    {
      return 5;
    }
  }
}

$ javac ReturnFinally.java -Xlint
ReturnFinally.java:22: warning: [finally] finally clause cannot complete normally
    }
    ^
1 warning

For this exercise, write an transformation that inserts a comment before return statements in a finally clause. This is not entirely trivial. Thanks to local and anonymous class declarations, not every return statement in a finally clause is incorrect. So, you need to handle these constructs in a special way.

It is useful to think about this transformation as format checking. If a Java source file does not use return statements in finally clauses, then the program can be described as being written in two different languages. First, in a finally clause the used language is a subset of the complete Java language: no return statements are allowed. Second, outside finally clauses, the full Java language is used. However, for local and anonymous class declarations in finally clauses the full language is supported as well.

A useful pattern for the implementation of these problems is to have two strategies, one for the complete language and one for the subset. In both strategies, specific cases are handled and maybe the context is switched to the other strategy. By default, they just traverse.

You need about 10 lines of code for this, so if your strategy is much longer, then you're doing something wrong ;)

Compile and apply:

$ cd return-finally
$ ./compile.sh
$ parse-java -i ReturnFinally.java | ./return-finally | pp-java
class ReturnFinally
{
  boolean error;

  int g()
  {
    if(error)
      throw new IllegalStateException();
    else
      return 4;
  }

  int f()
  {
    try
    {
      return g();
    }
    finally
    {
      // WARNING: return in finally
      return 5;
    }
  }
}

ReturnFinallyTricky.java is an example with a local class declaration.

Type-unifying strategies

Collect Literals

(work in directory collect-literals)

Note: If you have less than 45 minutes left, then it is a good idea to skip this exercise and only do the bytecode collect exercise.

Collect all literals (booleans, string, integers, etc) used in a Java source file and return them as a list. Use the template collect-literals.str.

Compile and apply:

$ cd collect-literals
$ ./compile.sh
$ parse-java -i SimpleProxyServer.java | ./collect-literals | pp-aterm
[ Deci("3")
, String([Chars("Wrong number of arguments.")])
, Deci("2")
, String([Chars("Starting proxy for ")])
, String([Chars(" on port ")])
, String([Chars("Usage: java SimpleProxyServer ")])
, String([Chars("<host> <remoteport> <localport>")])
, Deci("1024")
, Deci("4096")
, Bool(True())
, String([Chars("Proxy server cannot connect to ")])
, String([Chars(":")])
, String([Chars(":"), NamedEscape(110)])
, Deci("1")
, Deci("0")
, Null()
]

Collect Classes from Bytecode

(work in directory collect-classes)

Given a Java .class file, return the classes that are referred to using constructor calls (NEW), field accesses or method invocations. Use the template collect-classes.str.

Compile and apply:

$ cd collect-classes
$ ./compile.sh
$ javac YesNoDialog.java 

$ class2aterm -c -i YesNoDialog.class | ./collect-classes | pp-aterm
[ "java.awt.Dialog"
, "java.awt.BorderLayout"
, "MultiLineLabel"
, "YesNoDialog$1"
, "java.awt.FlowLayout"
, "java.awt.Button"
, "java.awt.Panel"
, "java.awt.AWTEventMulticaster"
, "java.awt.Frame"
, "YesNoDialog$2"
, "YesNoDialog"
]

$ class2aterm -c -i MultiLineLabel.class | ./collect-classes | pp-aterm
[ "java.awt.Canvas"
, "java.awt.Dimension"
, "java.awt.Graphics"
, "java.util.StringTokenizer"
, "java.awt.Toolkit"
, "java.awt.FontMetrics"
, "MultiLineLabel"
]

Note that is very easy to collect other information, for example constructors invoked from this class, methods that are invoked, fields that are accessed, etc.

Context-sensitive transformations

(work in the directory trace-instrument)

Implement a simple trace instrumentation tool that prints a message when a program enters and exits a method. Include the fully qualified name of the declaring class of the method in the message, wich you can propagate during the traversal using a scoped dynamic rule. Support member classes.

Compile and apply:

$ cd trace-instrument
$ ./compile.sh

$ parse-java -i Factorial2.java | ./trace-instrument  | pp-java -o Factorial.java
$ cat Factorial.java
public class Factorial
{
  public static long factorial(long x)
  {
    try
    {
      System.out.println("Enter Factorial.factorial");
      if(x == 1)
        return 1;
      else
        return x * factorial(x - 1);
    }
    finally
    {
      System.out.println("Exit Factorial.factorial");
    }
  }

  public static void main(String[] ps)
  {
    try
    {
      System.out.println("Enter Factorial.main");
      System.out.println("Factorial of 4 is " + factorial(4));
    }
    finally
    {
      System.out.println("Exit Factorial.main");
    }
  }
}

$ javac Factorial.java
$ java Factorial
Enter Factorial.main
Enter Factorial.factorial
Enter Factorial.factorial
Enter Factorial.factorial
Enter Factorial.factorial
Exit Factorial.factorial
Exit Factorial.factorial
Exit Factorial.factorial
Exit Factorial.factorial
Factorial of 4 is 24
Exit Factorial.main

fact/Tricky2.java is a bit more difficult:

$ parse-java -i fact/Tricky2.java | ./trace-instrument | pp-java -o fact/Tricky.java
$ javac fact/Tricky.java
$ java fact.Tricky
Enter fact.Tricky.main
Enter fact.Tricky.Factorial.apply
Enter fact.Tricky.Factorial.apply
Enter fact.Tricky.Factorial.apply
Enter fact.Tricky.Factorial.apply
Exit fact.Tricky.Factorial.apply
Exit fact.Tricky.Factorial.apply
Exit fact.Tricky.Factorial.apply
Exit fact.Tricky.Factorial.apply
Factorial of 4 is 24
Enter fact.Tricky.Multiply.apply
Exit fact.Tricky.Multiply.apply
4*4 is 16
Exit fact.Tricky.main

• http://www.cs.uu.nl/people/martin/ipa06/ipa06-slides.pdf

TU Delft 2006-11-20

The software for the TU Delft tutorial will be installed at the server apsone.st.ewi.tudelft.nl. You can compile your exercises on apsone and use X-forwarding with SSH for editing source files. Details of how to use this installation are available from the exercises.

We will install the tarballs available from the following release pages. If you want to install the software on your own computer (Linux or Mac/Intel prefered), then we advice to use the same versions.

• ATerm Library from:
  • http://nix.cs.uu.nl/dist/meta-environment/aterm-2.4.2pre20090-lvjs5798/

• SDF2 Bundle from:
  • http://nix.cs.uu.nl/dist/stratego/sdf2-bundle-2.3.4pre15345/

• Stratego/XT from:
  • http://nix.cs.uu.nl/dist/stratego/strategoxt-0.17M3pre15898/

• JavaFront from
  • http://nix.cs.uu.nl/dist/stratego/java-front-0.9pre15899-wq6slfzw/

• The Dryad from
  • http://nix.cs.uu.nl/dist/stratego/dryad-0.1pre15990-js8fa9xz/

• Stratego Shell from
  • http://nix.cs.uu.nl/dist/stratego/stratego-shell-0.7pre16004-klmc2slw

General

For the exercises we have used the following packages:

• Latest unstable release of Stratego/XT:
  • http://nix.cs.uu.nl/dist/stratego/strategoxt-unstable-latest/

• Latest unstable release of JavaFront:
  • http://nix.cs.uu.nl/dist/stratego/java-front-unstable-latest/

• Latest unstable release of The Dryad:
  • http://nix.cs.uu.nl/dist/stratego/dryad-unstable-latest/

• Latest unstable release of Stratego Shell:
  • http://nix.cs.uu.nl/dist/stratego/stratego-shell-unstable-latest/

See the webpages of these packages for installation instructions.

-- MartinBravenboer - 19 Sep 2006

Program

• 10.00 - 10.05: Introduction
• 10.05 - 10.45: Architecture & infrastructure
• 10.45 - 11:00: Break
• 11.00 - 11.45: Rewriting strategies
• 11.45 - 12.15: Type-unifying strategies

• 12.15 - 13.15: Lunch

• 13.15 - 14.00: Context-sensitive transformations
• 14.00 - 14.15: Break
• 14.15 - 16.00: Practical exercise
• 16.00 - 16.15: Summary & perspective

Feb 2008 881 0 0 281 WebStatistics
 74 WebHome
 65 WebRss
 59 WebChanges
 34 WebPreferences
 33 WebChanges200
 31 CourseExercises
 31 WebChanges100
 29 WebIndex
 26 CourseSoftware
 25 WebNotify   Jan 2008 2668 0 0 639 WebStatistics
253 WebHome
197 WebRss
162 WebChanges
153 CourseExercises
118 CourseSoftware
106 WebLeftBar
 98 CourseMaterial
 88 WebPreferences
 86 WebIndex
 75 WebNotify   Dec 2007 1838 0 0 347 WebStatistics
245 WebHome
158 WebRss
135 CourseExercises
 99 WebChanges
 87 CourseSoftware
 74 WebIndex
 73 WebNotify
 71 CourseMaterial
 66 WebNews
 59 WebLeftBar   Nov 2007 1516 0 0 421 WebStatistics
215 WebHome
 90 CourseExercises
 84 WebChanges
 64 WebIndex
 61 WebRss
 55 CourseSoftware
 49 WebNews
 43 WebNotify
 42 WebSearch
 42 WebPreferences   Oct 2007 1646 0 0 442 WebStatistics
210 WebHome
103 CourseExercises
 77 CourseSoftware
 75 WebChanges
 62 CourseMaterial
 61 WebLeftBar
 60 WebIndex
 60 WebNotify
 58 WebRss
 52 WebPreferences   Sep 2007 2186 0 0 922 WebStatistics
203 WebHome
104 CourseExercises
101 WebChanges
 81 CourseSoftware
 70 CourseMaterial
 69 WebChanges500
 61 WebRss
 55 WebIndex
 55 WebNotify
 55 WebNews   Aug 2007 3267 0 0 1563 WebStatistics
237 WebHome
150 WebChanges
114 CourseExercises
111 WebRss
 96 WebChanges500
 93 WebChanges200
 86 CourseSoftware
 86 CourseMaterial
 76 WebIndex
 74 WebLeftBar   Jul 2007 4379 0 0 1152 WebStatistics
364 WebHome
206 CourseExercises
202 CourseSoftware
200 WebChanges
187 WebLeftBar
160 WebIndex
158 CourseMaterial
148 WebRss
147 WebNotify
143 WebChanges200   Jun 2007 2066 0 0 318 WebStatistics
238 WebHome
111 CourseExercises
109 CourseSoftware
106 WebChanges
 87 WebIndex
 87 WebRss
 84 WebChanges500
 83 CourseMaterial
 83 WebLeftBar
 83 WebChanges200   May 2007 1793 0 0 440 WebStatistics
161 WebHome
117 CourseExercises
 84 WebChanges
 78 WebChanges500
 71 WebRss
 65 WebIndex
 65 WebLeftBar
 63 CourseMaterial
 62 WebPreferences
 61 CourseSoftware   Apr 2007 1626 0 0 286 WebStatistics
166 WebHome
116 CourseExercises
 91 WebChanges
 78 CourseSoftware
 75 WebNotify
 74 CourseMaterial
 68 WebRss
 68 WebNews
 58 WebIndex
 55 WebChanges500   Mar 2007 1728 0 0 461 WebStatistics
151 WebHome
141 CourseExercises
128 CourseMaterial
 84 CourseSoftware
 76 WebLeftBar
 65 WebChanges
 60 WebRss
 53 WebPreferences
 52 WebIndex
 48 WebNotify   Feb 2007 1449 0 0 458 WebStatistics
175 WebHome
 95 CourseExercises
 87 CourseSoftware
 59 WebPreferences
 56 WebChanges
 50 WebNotify
 50 CourseMaterial
 48 WebIndex
 42 WebRss
 42 WebLeftBar   Jan 2007 1315 0 0 241 WebStatistics
175 WebHome
 81 CourseExercises
 70 WebLeftBar
 68 WebChanges
 65 WebPreferences
 56 WebNotify
 55 CourseSoftware
 54 WebIndex
 49 WebSearch
 48 WebNews   Dec 2006 732 0 0 145 WebHome
 78 WebStatistics
 70 CourseExercises
 40 CourseSoftware
 38 WebIndex
 33 WebNotify
 32 CourseMaterial
 30 WebPreferences
 30 WebLeftBar
 24 WebRss
 23 WebChanges200   Nov 2006 675 17 0 148 WebHome
105 CourseExercises
 75 CourseSoftware
 51 WebRss
 42 CourseMaterial
 25 WebPreferences
 24 WebStatistics
 22 WebIndex
 21 WebNotify
 19 WebTopicList
 18 WebTools  17 MartinBravenboer Oct 2006 395 0 0  82 WebHome
 49 WebStatistics
 31 CourseExercises
 25 WebChanges
 24 CourseMaterial
 18 WebNotify
 18 WebRss
 17 CourseSoftware
 17 WebLeftBar
 13 WebSearch
 11 WebIndex   Sep 2006 233 33 0  75 WebHome
 48 CourseExercises
 17 WebLeftBar
 15 CourseSoftware
 14 CourseMaterial
  8 WebPreferences
  6 WebRss
  6 WebChanges
  4 WebNews
  4 WebIndex
  4 WebSearch  33 MartinBravenboer

Notes:

• Do not edit this topic, it is updated automatically. (You can also force an update)
• TWikiDocumentation tells you how to enable the automatic updates of the statistics.
• Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

• RoadMap^?
• WebIndex: all topics in the IPA06 web
• WebSearch: find topics

Tracking activity

• WebNews: selected changes
• WebChanges: recent changes
• WebNotify: email notification of changes
• WebStatistics: usage counts

Look and feel

• WebPreferences: values of variables
• WebContents^?: web specific entries in the side bar

• CourseExercises
• CourseMaterial
• CourseSoftware
• GettingStarted
• SiteMap
• UpdateWebPages
• WebChanges
• WebChanges100
• WebChanges200
• WebChanges500
• WebCustomMenus
• WebHome
• WebIndex
• WebLeftBar
• WebNews
• WebNotify
• WebPreferences
• WebRss
• WebSearch
• WebSearchAdvanced
• WebStatistics
• WebTools
• WebTopicList

See also the verbose WebIndex.